#include "customfileitem.h"
#include "layoutstatemanager.h"
#include <QApplication>
#include <QStyle>
#include <QPainter>
#include <QDebug>
#include <QFileInfo>
#include <QTextLayout>
CustomFileItem::CustomFileItem(const UnifiedFileInfo& fileInfo, QWidget* parent)
    : QWidget(parent),
      m_fileInfo(fileInfo),
      m_isSelected(false),
      m_isHovered(false),
      m_dragStartPos(0, 0),
      m_dragStarted(false),
      m_pressModifiers(Qt::NoModifier),
      m_adaptiveWidth(DEFAULT_ITEM_WIDTH)
{
    initializeUI();
    setMouseTracking(true);
    // 设置尺寸策略，允许水平方向的自适应调整
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    setFixedHeight(ITEM_HEIGHT);
    setFixedWidth(DEFAULT_ITEM_WIDTH);
}

// 【新增】虚拟化架构：无数据构造函数
CustomFileItem::CustomFileItem(QWidget* parent)
    : QWidget(parent),
      m_fileInfo(),  // 空的UnifiedFileInfo
      m_isSelected(false),
      m_isHovered(false),
      m_dragStartPos(0, 0),
      m_dragStarted(false),
      m_pressModifiers(Qt::NoModifier),
      m_adaptiveWidth(DEFAULT_ITEM_WIDTH)
{
    initializeUI();
    setMouseTracking(true);
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    setFixedHeight(ITEM_HEIGHT);
    setFixedWidth(DEFAULT_ITEM_WIDTH);
}

CustomFileItem::~CustomFileItem()
{
    // === 关键修复：析构时清理所有待处理的事件，防止窗口关闭时崩溃 ===
    
    // 1. 移除所有待处理的事件
    QCoreApplication::removePostedEvents(this);
    
    // 2. 立即停止接收任何新事件
    setEnabled(false);
    setAttribute(Qt::WA_TransparentForMouseEvents, true);
    setMouseTracking(false);
    setAttribute(Qt::WA_Hover, false);
    hide();
    
    // 3. 断开所有信号连接，防止析构过程中触发信号
    disconnect(this, nullptr, nullptr, nullptr);
    
    // 4. 确保对象销毁时清理状态
    m_dragStarted = false;
    m_pressModifiers = Qt::NoModifier;
    m_isSelected = false;
    m_isHovered = false;
}

void CustomFileItem::setFileInfo(const UnifiedFileInfo& fileInfo)
{
    
    m_fileInfo = fileInfo;
    update(); // 重新绘制
}
void CustomFileItem::setSelected(bool selected)
{
    if (m_isSelected != selected) {
        m_isSelected = selected;
        update();
    } else {
    }
}
void CustomFileItem::setHovered(bool hovered)
{
    if (m_isHovered != hovered) {
        m_isHovered = hovered;
        update();
    }
}
QSize CustomFileItem::sizeHint() const
{
    return QSize(m_adaptiveWidth, getLayoutParams().itemHeight);
}
QSize CustomFileItem::minimumSizeHint() const
{
    return QSize(MIN_ITEM_WIDTH, COMPACT_ITEM_HEIGHT);
}
void CustomFileItem::setAdaptiveWidth(int width)
{
    int clampedWidth = qMax(MIN_ITEM_WIDTH, width);
    if (m_adaptiveWidth != clampedWidth) {
        m_adaptiveWidth = clampedWidth;
        setFixedWidth(m_adaptiveWidth);
        // 根据新宽度调整高度
        LayoutParams params = getLayoutParams();
        setFixedHeight(params.itemHeight);
        
        // 【调试】输出高度计算信息
        qDebug() << "[响应式] 宽度:" << m_adaptiveWidth 
                 << " → 图标:" << params.iconSize 
                 << " 边距:" << params.margin 
                 << " → 计算高度:" << params.itemHeight
                 << " (应该 =" << (params.margin * 2 + params.iconSize) << ")";
        
        update(); // 重新绘制
    }
}
CustomFileItem::LayoutParams CustomFileItem::getLayoutParams() const
{
    LayoutParams params;
    
    // === 正确逻辑：先确定内容大小，再根据内容计算高度 ===
    
    if (m_adaptiveWidth < 120) {
        // 极致紧凑布局（100-120px）
        params.iconSize = 12;    
        params.fontSize = 8;     
        params.margin = 4;       
        params.spacing = 2;      
        params.showProgress = false;
        params.showLayoutInfo = false;
        // 单行布局：高度 = 上边距 + 图标 + 下边距
        params.itemHeight = params.margin + params.iconSize + params.margin;  // 4+12+4=20
        
    } else if (m_adaptiveWidth < 160) {
        // 超紧凑布局（120-160px）
        params.iconSize = 14;
        params.fontSize = 9;
        params.margin = 5;       
        params.spacing = 3;
        params.showProgress = false;
        params.showLayoutInfo = false;
        // 单行布局：高度 = 上边距 + 图标 + 下边距
        params.itemHeight = params.margin + params.iconSize + params.margin;  // 5+14+5=24
        
    } else if (m_adaptiveWidth < 220) {
        // 标准紧凑布局（160-220px）- 降低阈值，更早显示布局信息
        params.iconSize = 20;
        params.fontSize = 10;
        params.margin = 6;       
        params.spacing = 4;
        params.showProgress = true;
        params.showLayoutInfo = false;  // 还是单行
        // 单行布局：高度 = 上边距 + 图标 + 下边距
        params.itemHeight = params.margin + params.iconSize + params.margin;  // 6+20+6=32
        
    } else if (m_adaptiveWidth < 280) {
        // 小布局（开始显示布局信息）- 从220px开始显示
        params.iconSize = 24;
        params.fontSize = 10;
        params.margin = 8;       
        params.spacing = 4;
        params.showProgress = true;
        params.showLayoutInfo = true;  // 双行布局
        // 【关键修复】双行布局：需要容纳文件名+布局信息两行文本
        // 高度 = 上边距 + (行高*2 + 行间距) + 下边距 + 进度条空间
        QFont font;
        font.setPointSize(params.fontSize);
        QFontMetrics fm(font);
        int lineHeight = fm.lineSpacing();
        int textHeight = lineHeight * 2 + 4;  // 两行文本 + 4px行间距
        params.itemHeight = qMax(params.margin * 2 + params.iconSize, 
                                 params.margin * 2 + textHeight + 3);  // +3px留给进度条
        // 确保最小高度为 50px
        params.itemHeight = qMax(50, params.itemHeight);
        
    } else if (m_adaptiveWidth < 360) {
        // 完整布局
        params.iconSize = 26;
        params.fontSize = 11;
        params.margin = 10;       
        params.spacing = 5;
        params.showProgress = true;
        params.showLayoutInfo = true;  // 双行布局
        // 【关键修复】双行布局：需要容纳文件名+布局信息两行文本
        QFont font;
        font.setPointSize(params.fontSize);
        QFontMetrics fm(font);
        int lineHeight = fm.lineSpacing();
        int textHeight = lineHeight * 2 + 4;  // 两行文本 + 4px行间距
        params.itemHeight = qMax(params.margin * 2 + params.iconSize, 
                                 params.margin * 2 + textHeight + 3);  // +3px留给进度条
        // 确保最小高度为 56px
        params.itemHeight = qMax(56, params.itemHeight);
        
    } else {
        // 宽敞布局（>=360px）
        params.iconSize = 28;
        params.fontSize = 12;
        params.margin = 12;      
        params.spacing = 6;
        params.showProgress = true;
        params.showLayoutInfo = true;  // 双行布局
        // 【关键修复】双行布局：需要容纳文件名+布局信息两行文本
        QFont font;
        font.setPointSize(params.fontSize);
        QFontMetrics fm(font);
        int lineHeight = fm.lineSpacing();
        int textHeight = lineHeight * 2 + 5;  // 两行文本 + 5px行间距
        params.itemHeight = qMax(params.margin * 2 + params.iconSize, 
                                 params.margin * 2 + textHeight + 3);  // +3px留给进度条
        // 确保最小高度为 60px
        params.itemHeight = qMax(60, params.itemHeight);
    }
    
    return params;
}
void CustomFileItem::paintEvent(QPaintEvent* event)
{
    Q_UNUSED(event)
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing);
    // 绘制背景
    drawBackground(painter);
    // 绘制图标
    drawIcon(painter);
    // 绘制文本
    drawTexts(painter);
    // 绘制状态徽章
    drawStatusBadge(painter);
}
void CustomFileItem::mousePressEvent(QMouseEvent* event)
{
    // === 超级关键：最早的防护，防止访问已删除或半删除的对象 ===
    // 检查1：对象基本状态
    if (!isEnabled() || testAttribute(Qt::WA_TransparentForMouseEvents) || !isVisible()) {
        if (event) {
            event->ignore();
        }
        return;  // 立即返回，不调用父类方法
    }
    
    // 检查2：是否有父对象（如果setParent(nullptr)已调用，parent为空）
    if (!parent()) {
        if (event) {
            event->ignore();
        }
        return;  // 立即返回
    }
    
    // 检查3：信号是否被阻塞（如果blockSignals被调用）
    if (signalsBlocked()) {
        if (event) {
            event->ignore();
        }
        return;  // 立即返回
    }
    
    // 空指针保护
    if (!event) {
        return;
    }

    // === 所有检查通过，安全处理事件 ===
    if (event->button() == Qt::LeftButton) {
        m_dragStartPos = event->pos();
        m_dragStarted = false;
        // 保存按下时的键盘修饰符状态，但不立即发送点击信号
        m_pressModifiers = QApplication::keyboardModifiers();
    } else if (event->button() == Qt::RightButton) {
        emit rightClicked(this, event->globalPosition().toPoint());
    }
    
    // 再次检查对象状态（防止在处理过程中被标记删除）
    if (!isEnabled() || !parent()) {
        if (event) {
            event->ignore();
        }
        return;  // 不调用父类方法
    }
    
    // 确保调用父类方法
    QWidget::mousePressEvent(event);
}
void CustomFileItem::mouseReleaseEvent(QMouseEvent* event)
{
    // === 关键修复：最优先检查对象状态，防止在删除过程中处理事件 ===
    if (!isEnabled() || testAttribute(Qt::WA_TransparentForMouseEvents) || !isVisible()) {
        if (event) {
            event->ignore();
        }
        // 重置拖拽状态
        m_dragStarted = false;
        m_pressModifiers = Qt::NoModifier;
        return;
    }
    
    // 添加空指针检查
    if (!event) {
        return;
    }

    // 额外的对象有效性检查 - 防止访问损坏的内存
    try {
        // 使用Qt元对象系统检查对象有效性
        if (!metaObject() || metaObject()->className() != QByteArray("CustomFileItem")) {
            qWarning() << "CustomFileItem对象元信息损坏，跳过事件处理";
            event->ignore();
            return;
        }

        if (parent() && !parent()->children().contains(this)) {
            qWarning() << "CustomFileItem对象可能已损坏，跳过事件处理";
            event->ignore();
            return;
        }
    } catch (...) {
        qWarning() << "CustomFileItem对象访问异常，跳过事件处理";
        if (event) {
            event->ignore();
        }
        return;
    }

    if (event->button() == Qt::LeftButton) {
        // 只有在没有发生拖拽的情况下才发送点击信号
        if (!m_dragStarted) {
            emit clicked(this, m_pressModifiers);
        }
        // 安全地重置拖拽状态
        m_dragStarted = false;
        m_pressModifiers = Qt::NoModifier;
    }
    QWidget::mouseReleaseEvent(event);
}
void CustomFileItem::mouseDoubleClickEvent(QMouseEvent* event)
{
    // === 关键修复：最优先检查对象状态，防止在删除过程中处理事件 ===
    if (!isEnabled() || testAttribute(Qt::WA_TransparentForMouseEvents) || !isVisible()) {
        if (event) {
            event->ignore();
        }
        return;
    }
    
    // 添加空指针检查
    if (!event) {
        return;
    }

    if (event->button() == Qt::LeftButton) {
        emit doubleClicked(this);
    }
    QWidget::mouseDoubleClickEvent(event);
}
void CustomFileItem::mouseMoveEvent(QMouseEvent* event)
{
    // === 关键修复：最优先检查对象状态，防止在删除过程中处理事件 ===
    if (!isEnabled() || testAttribute(Qt::WA_TransparentForMouseEvents) || !isVisible()) {
        if (event) {
            event->ignore();
        }
        return;
    }
    
    // 添加空指针检查
    if (!event) {
        return;
    }

    if ((event->buttons() & Qt::LeftButton) && !m_dragStarted) {
        // 检查是否超过拖拽阈值
        int dragDistance = (event->pos() - m_dragStartPos).manhattanLength();
        if (dragDistance >= QApplication::startDragDistance()) {
            m_dragStarted = true;
            emit dragStartRequested(this, m_dragStartPos);
        }
    }
    QWidget::mouseMoveEvent(event);
}
void CustomFileItem::enterEvent(QEnterEvent* event)
{
    // === 关键修复：检查对象状态，防止在删除过程中处理事件 ===
    if (!isEnabled() || testAttribute(Qt::WA_TransparentForMouseEvents) || !isVisible()) {
        if (event) {
            event->ignore();
        }
        return;
    }
    
    setHovered(true);
    // 安全调用父类方法
    if (event) {
        QWidget::enterEvent(event);
    }
}
void CustomFileItem::leaveEvent(QEvent* event)
{
    // === 关键修复：检查对象状态，防止在删除过程中处理事件 ===
    if (!isEnabled() || testAttribute(Qt::WA_TransparentForMouseEvents) || !isVisible()) {
        if (event) {
            event->ignore();
        }
        return;
    }
    
    setHovered(false);
    // 安全调用父类方法
    if (event) {
        QWidget::leaveEvent(event);
    }
}
void CustomFileItem::initializeUI()
{
    // 设置基本属性
    setAttribute(Qt::WA_Hover);
    setFocusPolicy(Qt::NoFocus);
    // 禁用自动填充背景，让paintEvent完全控制背景绘制
    setAutoFillBackground(false);
}
QString CustomFileItem::getLayoutModeText() const
{
    switch (UnifiedFileInfo::layoutModeToInt(m_fileInfo.layoutMode)) {
        case 1: return "单栏";
        case 2: return "双栏";
        case 3: return "三栏";
        default: return "单栏";
    }
}
QIcon CustomFileItem::getStatusIcon() const
{
    // 优先根据文件后缀判定（更可靠），再根据声明的fileType判定
    QString ext = QFileInfo(m_fileInfo.filePath).suffix().toLower();
    if (ext == "pdf") return QIcon(":/icons/pdf_file.png");
    if (ext == "png") return QIcon(":/icons/png_file.png");
    if (ext == "jpg") return QIcon(":/icons/jpg_file.png");
    if (ext == "jpeg") return QIcon(":/icons/jpeg_file.png");
    if (ext == "bmp" || ext == "gif" || ext == "tiff" || ext == "webp") return QIcon(":/icons/image_file.png");
    QString type = UnifiedFileInfo::fileTypeToString(m_fileInfo.fileType).toLower();
    if (type == "pdf") return QIcon(":/icons/pdf_file.png");
    if (type == "png") return QIcon(":/icons/png_file.png");
    if (type == "jpg") return QIcon(":/icons/jpg_file.png");
    if (type == "jpeg") return QIcon(":/icons/jpeg_file.png");
    if (type == "image" || type == "bmp" || type == "gif" || type == "tiff" || type == "webp")
        return QIcon(":/icons/image_file.png");
    // 回退到通用图片图标
    return QIcon(":/icons/image_file.png");
}
void CustomFileItem::drawBackground(QPainter& painter)
{
    // 高亮背景几乎贴边，最大化利用窗口空间
    QRect rect = this->rect().adjusted(1, 1, -1, -1);
    
    // 检查是否正在被拖拽
    bool isDragging = property("isDragging").toBool();
    
    if (isDragging) {
        // 拖拽状态 - 使用半透明效果，表示正在被拖拽
        QLinearGradient gradient(0, 0, 0, height());
        gradient.setColorAt(0, QColor(0, 122, 255, 100));  // 半透明蓝色
        gradient.setColorAt(1, QColor(0, 100, 220, 100));
        
        painter.setBrush(QBrush(gradient));
        painter.setPen(QPen(QColor(0, 122, 255, 200), 2));  // 更明显的边框
        painter.drawRoundedRect(rect, 8, 8);
        
        // 添加拖拽时的特殊效果
        painter.setPen(QPen(QColor(255, 255, 255, 150), 1));
        painter.drawRoundedRect(rect.adjusted(1, 1, -1, -1), 8, 8);
        
    } else if (m_isSelected) {
        // 选中状态 - 使用渐变背景和边框，符合Apple设计理念
        QLinearGradient gradient(0, 0, 0, height());
        gradient.setColorAt(0, QColor(240, 248, 255));  // 顶部浅蓝
        gradient.setColorAt(1, QColor(230, 240, 255));  // 底部更浅
        
        painter.setBrush(QBrush(gradient));
        painter.setPen(QPen(QColor(0, 122, 255, 150), 1));  // 蓝色边框
        painter.drawRoundedRect(rect, 8, 8);
        
        // 添加轻微阴影效果，增强层次感
        painter.setPen(QPen(QColor(0, 0, 0, 20), 1));
        painter.drawRoundedRect(rect.adjusted(0, 1, 1, 1), 8, 8);
        
    } else if (m_isHovered) {
        // 悬停状态 - 微妙的反馈，与#f0f0f0背景协调
        painter.setBrush(QBrush(QColor(235, 235, 235)));  // 比#f0f0f0稍亮
        painter.setPen(Qt::NoPen);
        painter.drawRoundedRect(rect, 8, 8);
    } else {
        // 正常状态 - 透明背景
        painter.setBrush(Qt::NoBrush);
        painter.setPen(Qt::NoPen);
    }
}
void CustomFileItem::drawIcon(QPainter& painter)
{
    LayoutParams params = getLayoutParams();
    QIcon icon = getStatusIcon();
    QRect iconRect(params.margin, (height() - params.iconSize) / 2, params.iconSize, params.iconSize);
    icon.paint(&painter, iconRect);
}
void CustomFileItem::drawTexts(QPainter& painter)
{
    LayoutParams params = getLayoutParams();
    // 设置文本颜色，在渐变背景上保持良好可读性
    QColor textColor;
    if (m_isSelected) {
        // 选中状态：使用深色文字，在浅蓝渐变背景上清晰可见
        textColor = QColor(20, 20, 20); // 深灰色，比纯黑更柔和
    } else {
        // 未选中状态：使用系统默认文字颜色
        textColor = palette().color(QPalette::Text);
    }
    painter.setPen(textColor);
    int iconRight = params.margin + params.iconSize + params.spacing;
    // 根据布局模式调整右侧边距，适配100px最小宽度
    int rightPadding;
    if (m_adaptiveWidth < 120) {
        rightPadding = 1;  // 极致紧凑模式：最小边距
    } else if (m_adaptiveWidth < 200) {
        rightPadding = 2;  // 超紧凑模式：极小边距
    } else if (m_adaptiveWidth < 280) {
        rightPadding = 3;  // 紧凑模式：小边距
    } else if (m_adaptiveWidth < 360) {
        rightPadding = 5;  // 正常模式：适中边距
    } else {
        rightPadding = 8;  // 宽敞模式：较大边距，更好展示大字体
    }
    int availableWidth = width() - iconRight - params.margin - rightPadding;
    // 主文本起始区域（文件名）
    QRect textRect(iconRight, params.margin, availableWidth, height() - 2 * params.margin);
    // 设置字体 - Jony Ive风格：简洁、清晰、宽窗口时加粗
    QFont nameFont = font();
    nameFont.setPointSize(params.fontSize); // 使用自适应字体大小
    // 宽窗口（>=360px）时加粗，突出文件名
    if (m_adaptiveWidth >= 360) {
        nameFont.setBold(true); // 宽敞布局时加粗
    } else {
        nameFont.setBold(false); // 默认不加粗，保持简洁
    }
    painter.setFont(nameFont);
    // 绘制文件名（根据是否显示布局信息调整垂直对齐）
    QFontMetrics nameFM(nameFont);
    const int lineHeight = nameFM.lineSpacing();
    QRect nameRect;
    Qt::Alignment textAlignment;
    if (params.showLayoutInfo) {
        // Jony Ive风格：显示布局信息时，文件名在上方，给更多垂直空间
        nameRect = textRect;
        nameRect.setHeight(lineHeight + 2); // 增加2px垂直空间
        nameRect.adjust(0, 2, 0, -1); // 向下偏移2px，避免顶部贴边
        textAlignment = Qt::AlignLeft | Qt::AlignTop;
    } else {
        // Jony Ive风格：不显示布局信息时，文件名完美居中
        nameRect = textRect;
        nameRect.adjust(0, -1, 0, 0); // 微调1px向上，完美居中
        textAlignment = Qt::AlignLeft | Qt::AlignVCenter;
    }
    // 根据可用宽度调整文件名显示策略（优化空间利用）
    QString normalized = m_fileInfo.fileName;
    // 计算实际可用的文本宽度
    QFontMetrics fm(nameFont);
    int actualTextWidth = availableWidth;
    if (m_adaptiveWidth < 120) {
        // 极致紧凑模式：只显示文件名首字母或极简缩写
        QFileInfo fileInfo(m_fileInfo.fileName);
        normalized = fileInfo.baseName();
        if (normalized.length() > 3) {
            normalized = normalized.left(2) + QChar(0x2026); // 只显示2个字符加省略号
        }
    } else if (m_adaptiveWidth < 160) {
        // 超紧凑模式：显示极简文件名
        QFileInfo fileInfo(m_fileInfo.fileName);
        normalized = fileInfo.baseName();
        int maxChars = actualTextWidth / fm.averageCharWidth();
        if (normalized.length() > maxChars && maxChars > 2) {
            normalized = normalized.left(maxChars - 1) + QChar(0x2026);
        }
    } else if (m_adaptiveWidth < 280) {
        // 标准紧凑模式
        int maxChars = actualTextWidth / fm.averageCharWidth();
        if (normalized.length() > maxChars && maxChars > 8) {
            QString left = normalized.left(maxChars * 0.6);
            QString right = normalized.right(maxChars * 0.4 - 1);
            normalized = left + QChar(0x2026) + right;
        }
    } else {
        // 宽布局：尽可能显示完整文件名
        // 让Qt的elidedText来处理，它会更精确
    }
    // 单行宽度保护
    QString display = nameFM.elidedText(normalized, Qt::ElideRight, qMax(0, availableWidth));
    // 绘制单行
    painter.save();
    painter.setClipRect(nameRect);
    painter.drawText(nameRect, textAlignment, display);
    painter.restore();
    // 绘制页数和布局信息（仅在有足够空间时显示）
    if (params.showLayoutInfo && nameRect.bottom() + 6 < height() - params.margin) { // Jony Ive风格：增加6px底部空间
        // 设置信息字体（字体缩小2号，最小6pt，增加呼吸感）
        QFont infoFont = font();
        infoFont.setPointSize(qMax(6, params.fontSize - 1));
        painter.setFont(infoFont);
        // 从LayoutStateManager获取正确的布局模式和计算页数
        LayoutMode mode = LayoutStateManager::convertFromOldLayoutMode(UnifiedFileInfo::layoutModeToInt(m_fileInfo.layoutMode));
        int calculatedPageCount = LayoutStateManager::calculateDisplayPages(mode, m_fileInfo.pageCount);
        QString layoutText = LayoutStateManager::getLayoutModeText(mode);
        QString infoText = QString("%1页 · %2").arg(calculatedPageCount).arg(layoutText);
        QRect infoRect = textRect;
        infoRect.setTop(nameRect.bottom() + 4); // Jony Ive风格：增加4px间距，更优雅
        infoRect.setHeight(QFontMetrics(infoFont).height() + 1); // 增加1px高度避免截断
        // 布局信息颜色，在选中状态下保持良好对比度
        QColor infoColor;
        if (m_isSelected) {
            // 选中状态：使用中等灰色，在浅蓝背景上清晰可见
            infoColor = QColor(100, 100, 100); // 中等灰色
        } else {
            // 未选中状态：使用系统默认暗色
            infoColor = palette().color(QPalette::Dark);
        }
        painter.setPen(infoColor);
        QFontMetrics infoFM(infoFont);
        // 现在进度条在底部显示，布局信息可以使用全部可用宽度
        infoText = infoFM.elidedText(infoText, Qt::ElideRight, qMax(0, availableWidth));
        painter.save();
        painter.setClipRect(infoRect);
        painter.drawText(infoRect, Qt::AlignLeft | Qt::AlignTop, infoText);
        painter.restore();
    }
}
void CustomFileItem::drawStatusBadge(QPainter& painter)
{
    LayoutParams params = getLayoutParams();
    // 如果是处理中状态且有进度，绘制底部进度条
    bool isProcessing = (m_fileInfo.processStatus == FileProcessStatus::Processing || 
                        m_fileInfo.status == FileStatusIconManager::FileStatus::Processing) && 
                       m_fileInfo.progress > 0;
    
    
    if (isProcessing && params.showProgress) {
        // 绘制底部细长进度条，跨越整个宽度
        int progressHeight = 3; // 进度条高度，细长
        int margin = 2; // 左右边距
        // 进度条位置：在整个项目的最底部
        QRect progressBg(margin, height() - progressHeight, 
                        width() - 2 * margin, progressHeight);
        // 绘制进度条背景（淡灰色）
        painter.setBrush(QBrush(QColor(240, 240, 240)));
        painter.setPen(Qt::NoPen);
        painter.drawRect(progressBg); // 使用直角形，更像底框
        // 计算进度宽度
        int progressValue = qBound(0, m_fileInfo.progress, 100);
        int progressWidth = (progressBg.width() * progressValue) / 100;
        if (progressWidth > 0) {
            QRect progressFill(progressBg.x(), progressBg.y(), 
                              progressWidth, progressBg.height());
            // 根据选中状态选择进度条颜色，确保在渐变背景上有足够对比度
            QColor progressColor;
            if (m_isSelected) {
                // 选中状态：使用深蓝色进度条，在渐变背景上有足够对比度
                progressColor = QColor(0, 100, 220); // 深蓝色，在浅蓝背景上清晰可见
            } else {
                // 未选中状态：保持原有蓝色
                progressColor = QColor(0, 122, 255); // 蓝色
            }
            painter.setBrush(QBrush(progressColor));
            painter.drawRect(progressFill); // 使用直角形
            
        }
    }
}